package com.ourteam.workspace.dao;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;

/**
 * Template Name : DAO查询对象 Template Version : 1 Template Last Modfiy Date : Sat Aug 19 10:06:32 CST
 * 2017 Auto Generate Date : 2018-11-30 18:42:31 Warning ! This file will be overwrite when
 * regenerate !
 */
public class WorkspaceMemberDAOQueryBean extends BaseQueryBean {

  public WorkspaceMemberDAOQueryBean() {
    super();
  }

  public WorkspaceMemberDAOQueryBean(BaseQueryBean aQueryBean) {
    super(aQueryBean);
  }

  public WorkspaceMemberDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
    super(aQueryBean, tableReplaceMap);
  }

  public Criteria createCriteria() {

    Criteria criteria = createCriteriaInternal();
    if (oredCriteria.size() == 0) {
      oredCriteria.add(criteria);
    }
    return criteria;
  }

  protected Criteria createCriteriaInternal() {
    return new Criteria(this);
  }

  public void addIdSelectProperty() {
    addIdSelectProperty("id");
  }

  public void addIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceMemberDAO.Id, aAlias);
    } else {
      addSelectProperty(IWorkspaceMemberDAO.Id, "id");
    }
  }

  public void addSysUserIdSelectProperty() {
    addSysUserIdSelectProperty("sysUserId");
  }

  public void addSysUserIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceMemberDAO.SysUserId, aAlias);
    } else {
      addSelectProperty(IWorkspaceMemberDAO.SysUserId, "sysUserId");
    }
  }

  public void addScmAccountSelectProperty() {
    addScmAccountSelectProperty("scmAccount");
  }

  public void addScmAccountSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceMemberDAO.ScmAccount, aAlias);
    } else {
      addSelectProperty(IWorkspaceMemberDAO.ScmAccount, "scmAccount");
    }
  }

  public void addRoleSelectProperty() {
    addRoleSelectProperty("role");
  }

  public void addRoleSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceMemberDAO.Role, aAlias);
    } else {
      addSelectProperty(IWorkspaceMemberDAO.Role, "role");
    }
  }

  public void addLastChangeCodeLineSelectProperty() {
    addLastChangeCodeLineSelectProperty("lastChangeCodeLine");
  }

  public void addLastChangeCodeLineSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceMemberDAO.LastChangeCodeLine, aAlias);
    } else {
      addSelectProperty(IWorkspaceMemberDAO.LastChangeCodeLine, "lastChangeCodeLine");
    }
  }

  public void addStatusSelectProperty() {
    addStatusSelectProperty("status");
  }

  public void addStatusSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceMemberDAO.Status, aAlias);
    } else {
      addSelectProperty(IWorkspaceMemberDAO.Status, "status");
    }
  }

  public void addRemarksSelectProperty() {
    addRemarksSelectProperty("remarks");
  }

  public void addRemarksSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceMemberDAO.Remarks, aAlias);
    } else {
      addSelectProperty(IWorkspaceMemberDAO.Remarks, "remarks");
    }
  }

  public void addLastActivityTimeSelectProperty() {
    addLastActivityTimeSelectProperty("lastActivityTime");
  }

  public void addLastActivityTimeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceMemberDAO.LastActivityTime, aAlias);
    } else {
      addSelectProperty(IWorkspaceMemberDAO.LastActivityTime, "lastActivityTime");
    }
  }

  public void addWorkspaceIdSelectProperty() {
    addWorkspaceIdSelectProperty("workspaceId");
  }

  public void addWorkspaceIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceMemberDAO.WorkspaceId, aAlias);
    } else {
      addSelectProperty(IWorkspaceMemberDAO.WorkspaceId, "workspaceId");
    }
  }

  public void addUserNameSelectProperty() {
    addUserNameSelectProperty("userName");
  }

  public void addUserNameSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceMemberDAO.UserName, aAlias);
    } else {
      addSelectProperty(IWorkspaceMemberDAO.UserName, "userName");
    }
  }

  public void addAllSelectProperties() {

    addIdSelectProperty();

    addSysUserIdSelectProperty();

    addScmAccountSelectProperty();

    addRoleSelectProperty();

    addLastChangeCodeLineSelectProperty();

    addStatusSelectProperty();

    addRemarksSelectProperty();

    addLastActivityTimeSelectProperty();

    addWorkspaceIdSelectProperty();

    addUserNameSelectProperty();
  }

  public static class Criteria extends BaseWhereCriterion<WorkspaceMemberDAOQueryBean> {

    protected Criteria(WorkspaceMemberDAOQueryBean aParentObject) {
      super(aParentObject);
    }

    public Criteria andIdIsNull() {
      addCriterion(IWorkspaceMemberDAO.Id + " is null");
      return this;
    }

    public Criteria andIdIsNotNull() {
      addCriterion(IWorkspaceMemberDAO.Id + " is not null");
      return this;
    }

    public Criteria andIdIsNotEmpty() {
      addCriterion(
          IWorkspaceMemberDAO.Id + " is not null AND " + IWorkspaceMemberDAO.Id + " <> ''");
      return this;
    }

    public Criteria andIdIsEmpty() {
      addCriterion(
          "(" + IWorkspaceMemberDAO.Id + " is null OR " + IWorkspaceMemberDAO.Id + " = '')");
      return this;
    }

    public Criteria andIdEqualTo(long value) {
      return andIdEqualTo(Long.valueOf(value));
    }

    public Criteria andIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.Id + " = ", value, "id");
      return this;
    }

    public Criteria andIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Id);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Id + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotEqualTo(long value) {
      return andIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToOrIsNull(long value) {
      return andIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceMemberDAO.Id + " is null OR " + IWorkspaceMemberDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Id);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Id + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThan(long value) {
      return andIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.Id + " >", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Id);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Id + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(long value) {
      return andIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.Id + " >=", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Id);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Id + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThan(long value) {
      return andIdLessThan(Long.valueOf(value));
    }

    public Criteria andIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.Id + " <", value, "id");
      return this;
    }

    public Criteria andIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Id);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Id + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(long value) {
      return andIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.Id + " <=", value, "id");
      return this;
    }

    public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Id);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Id + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdIn(long[] values) {
      if (values.length == 1) {
        return andIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.Id + " in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.Id + " not in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Id + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Id + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceMemberDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceMemberDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceMemberDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceMemberDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andSysUserIdIsNull() {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " is null");
      return this;
    }

    public Criteria andSysUserIdIsNotNull() {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " is not null");
      return this;
    }

    public Criteria andSysUserIdIsNotEmpty() {
      addCriterion(
          IWorkspaceMemberDAO.SysUserId
              + " is not null AND "
              + IWorkspaceMemberDAO.SysUserId
              + " <> ''");
      return this;
    }

    public Criteria andSysUserIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceMemberDAO.SysUserId
              + " is null OR "
              + IWorkspaceMemberDAO.SysUserId
              + " = '')");
      return this;
    }

    public Criteria andSysUserIdEqualTo(long value) {
      return andSysUserIdEqualTo(Long.valueOf(value));
    }

    public Criteria andSysUserIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.SysUserId + " = ", value, "sysUserId");
      return this;
    }

    public Criteria andSysUserIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.SysUserId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSysUserIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andSysUserIdNotEqualTo(long value) {
      return andSysUserIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andSysUserIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.SysUserId + " <>", value, "sysUserId");
      return this;
    }

    public Criteria andSysUserIdNotEqualToOrIsNull(long value) {
      return andSysUserIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andSysUserIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceMemberDAO.SysUserId + " is null OR " + IWorkspaceMemberDAO.SysUserId + " <>",
          value,
          "sysUserId");
      return this;
    }

    public Criteria andSysUserIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.SysUserId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSysUserIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andSysUserIdGreaterThan(long value) {
      return andSysUserIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andSysUserIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.SysUserId + " >", value, "sysUserId");
      return this;
    }

    public Criteria andSysUserIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.SysUserId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSysUserIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andSysUserIdGreaterThanOrEqualTo(long value) {
      return andSysUserIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andSysUserIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.SysUserId + " >=", value, "sysUserId");
      return this;
    }

    public Criteria andSysUserIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.SysUserId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSysUserIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andSysUserIdLessThan(long value) {
      return andSysUserIdLessThan(Long.valueOf(value));
    }

    public Criteria andSysUserIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.SysUserId + " <", value, "sysUserId");
      return this;
    }

    public Criteria andSysUserIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.SysUserId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSysUserIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andSysUserIdLessThanOrEqualTo(long value) {
      return andSysUserIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andSysUserIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.SysUserId + " <=", value, "sysUserId");
      return this;
    }

    public Criteria andSysUserIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.SysUserId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSysUserIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andSysUserIdIn(long[] values) {
      if (values.length == 1) {
        return andSysUserIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.SysUserId + " in", values, "sysUserId");
        return this;
      }
    }

    public Criteria andSysUserIdNotIn(long[] values) {
      if (values.length == 1) {
        return andSysUserIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.SysUserId + " not in", values, "sysUserId");
        return this;
      }
    }

    public Criteria andSysUserIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andSysUserIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.SysUserId + " in", values, "sysUserId");
        return this;
      }
    }

    public Criteria andSysUserIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andSysUserIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.SysUserId + " not in", values, "sysUserId");
        return this;
      }
    }

    public Criteria andSysUserIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andSysUserIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.SysUserId + " in", Arrays.asList(values), "sysUserId");
        return this;
      }
    }

    public Criteria andSysUserIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andSysUserIdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.SysUserId + " not in", Arrays.asList(values), "sysUserId");
        return this;
      }
    }

    public Criteria andSysUserIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andSysUserIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andSysUserIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " between", value1, value2, "sysUserId");
      return this;
    }

    public Criteria andSysUserIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " between", value1, value2, "sysUserId");
      return this;
    }

    public Criteria andSysUserIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " not between", value1, value2, "sysUserId");
      return this;
    }

    public Criteria andSysUserIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceMemberDAO.SysUserId + " not between", value1, value2, "sysUserId");
      return this;
    }

    public Criteria andScmAccountIsNull() {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " is null");
      return this;
    }

    public Criteria andScmAccountIsNotNull() {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " is not null");
      return this;
    }

    public Criteria andScmAccountIsNotEmpty() {
      addCriterion(
          IWorkspaceMemberDAO.ScmAccount
              + " is not null AND "
              + IWorkspaceMemberDAO.ScmAccount
              + " <> ''");
      return this;
    }

    public Criteria andScmAccountIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceMemberDAO.ScmAccount
              + " is null OR "
              + IWorkspaceMemberDAO.ScmAccount
              + " = '')");
      return this;
    }

    public Criteria andScmAccountEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.ScmAccount + " = ", value, "scmAccount");
      return this;
    }

    public Criteria andScmAccountEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.ScmAccount);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmAccountEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmAccountNotEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.ScmAccount + " <>", value, "scmAccount");
      return this;
    }

    public Criteria andScmAccountNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceMemberDAO.ScmAccount + " is null OR " + IWorkspaceMemberDAO.ScmAccount + " <>",
          value,
          "scmAccount");
      return this;
    }

    public Criteria andScmAccountNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.ScmAccount);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmAccountNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmAccountGreaterThan(String value) {

      addCriterion(IWorkspaceMemberDAO.ScmAccount + " >", value, "scmAccount");
      return this;
    }

    public Criteria andScmAccountGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.ScmAccount);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmAccountGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmAccountGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.ScmAccount + " >=", value, "scmAccount");
      return this;
    }

    public Criteria andScmAccountGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.ScmAccount);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmAccountGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmAccountLessThan(String value) {

      addCriterion(IWorkspaceMemberDAO.ScmAccount + " <", value, "scmAccount");
      return this;
    }

    public Criteria andScmAccountLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.ScmAccount);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmAccountLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmAccountLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.ScmAccount + " <=", value, "scmAccount");
      return this;
    }

    public Criteria andScmAccountLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.ScmAccount);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmAccountLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmAccountLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " like", buffer.toString(), "scmAccount");
      return this;
    }

    public Criteria andScmAccountNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " not like", buffer.toString(), "scmAccount");
      return this;
    }

    public Criteria andScmAccountIn(List<String> values) {

      if (values.size() == 1) {
        return andScmAccountEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.ScmAccount + " in", values, "scmAccount");
        return this;
      }
    }

    public Criteria andScmAccountNotIn(List<String> values) {
      if (values.size() == 1) {
        return andScmAccountNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.ScmAccount + " not in", values, "scmAccount");
        return this;
      }
    }

    public Criteria andScmAccountIn(String[] values) {

      if (values.length == 1) {
        return andScmAccountEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.ScmAccount + " in", Arrays.asList(values), "scmAccount");
        return this;
      }
    }

    public Criteria andScmAccountNotIn(String[] values) {
      if (values.length == 1) {
        return andScmAccountNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceMemberDAO.ScmAccount + " not in", Arrays.asList(values), "scmAccount");
        return this;
      }
    }

    public Criteria andScmAccountIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmAccountNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmAccountBetween(String value1, String value2) {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " between", value1, value2, "scmAccount");
      return this;
    }

    public Criteria andScmAccountNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceMemberDAO.ScmAccount + " not between", value1, value2, "scmAccount");
      return this;
    }

    public Criteria andRoleIsNull() {
      addCriterion(IWorkspaceMemberDAO.Role + " is null");
      return this;
    }

    public Criteria andRoleIsNotNull() {
      addCriterion(IWorkspaceMemberDAO.Role + " is not null");
      return this;
    }

    public Criteria andRoleIsNotEmpty() {
      addCriterion(
          IWorkspaceMemberDAO.Role + " is not null AND " + IWorkspaceMemberDAO.Role + " <> ''");
      return this;
    }

    public Criteria andRoleIsEmpty() {
      addCriterion(
          "(" + IWorkspaceMemberDAO.Role + " is null OR " + IWorkspaceMemberDAO.Role + " = '')");
      return this;
    }

    public Criteria andRoleEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Role + " = ", value, "role");
      return this;
    }

    public Criteria andRoleEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Role);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRoleEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Role + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRoleNotEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Role + " <>", value, "role");
      return this;
    }

    public Criteria andRoleNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceMemberDAO.Role + " is null OR " + IWorkspaceMemberDAO.Role + " <>",
          value,
          "role");
      return this;
    }

    public Criteria andRoleNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Role);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRoleNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Role + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRoleGreaterThan(String value) {

      addCriterion(IWorkspaceMemberDAO.Role + " >", value, "role");
      return this;
    }

    public Criteria andRoleGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Role);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRoleGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Role + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRoleGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Role + " >=", value, "role");
      return this;
    }

    public Criteria andRoleGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Role);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRoleGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Role + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRoleLessThan(String value) {

      addCriterion(IWorkspaceMemberDAO.Role + " <", value, "role");
      return this;
    }

    public Criteria andRoleLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Role);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRoleLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Role + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRoleLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Role + " <=", value, "role");
      return this;
    }

    public Criteria andRoleLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Role);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRoleLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Role + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRoleLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceMemberDAO.Role + " like", buffer.toString(), "role");
      return this;
    }

    public Criteria andRoleNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceMemberDAO.Role + " not like", buffer.toString(), "role");
      return this;
    }

    public Criteria andRoleIn(List<String> values) {

      if (values.size() == 1) {
        return andRoleEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.Role + " in", values, "role");
        return this;
      }
    }

    public Criteria andRoleNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRoleNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.Role + " not in", values, "role");
        return this;
      }
    }

    public Criteria andRoleIn(String[] values) {

      if (values.length == 1) {
        return andRoleEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.Role + " in", Arrays.asList(values), "role");
        return this;
      }
    }

    public Criteria andRoleNotIn(String[] values) {
      if (values.length == 1) {
        return andRoleNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.Role + " not in", Arrays.asList(values), "role");
        return this;
      }
    }

    public Criteria andRoleIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Role + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRoleNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Role + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRoleBetween(String value1, String value2) {
      addCriterion(IWorkspaceMemberDAO.Role + " between", value1, value2, "role");
      return this;
    }

    public Criteria andRoleNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceMemberDAO.Role + " not between", value1, value2, "role");
      return this;
    }

    public Criteria andLastChangeCodeLineIsNull() {
      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " is null");
      return this;
    }

    public Criteria andLastChangeCodeLineIsNotNull() {
      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " is not null");
      return this;
    }

    public Criteria andLastChangeCodeLineIsNotEmpty() {
      addCriterion(
          IWorkspaceMemberDAO.LastChangeCodeLine
              + " is not null AND "
              + IWorkspaceMemberDAO.LastChangeCodeLine
              + " <> ''");
      return this;
    }

    public Criteria andLastChangeCodeLineIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceMemberDAO.LastChangeCodeLine
              + " is null OR "
              + IWorkspaceMemberDAO.LastChangeCodeLine
              + " = '')");
      return this;
    }

    public Criteria andLastChangeCodeLineEqualTo(int value) {
      return andLastChangeCodeLineEqualTo(Integer.valueOf(value));
    }

    public Criteria andLastChangeCodeLineEqualTo(java.lang.Integer value) {

      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " = ", value, "lastChangeCodeLine");
      return this;
    }

    public Criteria andLastChangeCodeLineEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastChangeCodeLine);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastChangeCodeLineEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastChangeCodeLineNotEqualTo(int value) {
      return andLastChangeCodeLineNotEqualTo(Integer.valueOf(value));
    }

    public Criteria andLastChangeCodeLineNotEqualTo(java.lang.Integer value) {

      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " <>", value, "lastChangeCodeLine");
      return this;
    }

    public Criteria andLastChangeCodeLineNotEqualToOrIsNull(int value) {
      return andLastChangeCodeLineNotEqualToOrIsNull(Integer.valueOf(value));
    }

    public Criteria andLastChangeCodeLineNotEqualToOrIsNull(java.lang.Integer value) {

      addCriterion(
          IWorkspaceMemberDAO.LastChangeCodeLine
              + " is null OR "
              + IWorkspaceMemberDAO.LastChangeCodeLine
              + " <>",
          value,
          "lastChangeCodeLine");
      return this;
    }

    public Criteria andLastChangeCodeLineNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastChangeCodeLine);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastChangeCodeLineNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastChangeCodeLineGreaterThan(int value) {
      return andLastChangeCodeLineGreaterThan(Integer.valueOf(value));
    }

    public Criteria andLastChangeCodeLineGreaterThan(java.lang.Integer value) {

      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " >", value, "lastChangeCodeLine");
      return this;
    }

    public Criteria andLastChangeCodeLineGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastChangeCodeLine);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastChangeCodeLineGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastChangeCodeLineGreaterThanOrEqualTo(int value) {
      return andLastChangeCodeLineGreaterThanOrEqualTo(Integer.valueOf(value));
    }

    public Criteria andLastChangeCodeLineGreaterThanOrEqualTo(java.lang.Integer value) {

      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " >=", value, "lastChangeCodeLine");
      return this;
    }

    public Criteria andLastChangeCodeLineGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastChangeCodeLine);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastChangeCodeLineGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastChangeCodeLineLessThan(int value) {
      return andLastChangeCodeLineLessThan(Integer.valueOf(value));
    }

    public Criteria andLastChangeCodeLineLessThan(java.lang.Integer value) {

      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " <", value, "lastChangeCodeLine");
      return this;
    }

    public Criteria andLastChangeCodeLineLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastChangeCodeLine);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastChangeCodeLineLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastChangeCodeLineLessThanOrEqualTo(int value) {
      return andLastChangeCodeLineLessThanOrEqualTo(Integer.valueOf(value));
    }

    public Criteria andLastChangeCodeLineLessThanOrEqualTo(java.lang.Integer value) {

      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " <=", value, "lastChangeCodeLine");
      return this;
    }

    public Criteria andLastChangeCodeLineLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastChangeCodeLine);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastChangeCodeLineLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastChangeCodeLineIn(int[] values) {
      if (values.length == 1) {
        return andLastChangeCodeLineEqualTo((java.lang.Integer) values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " in", values, "lastChangeCodeLine");
        return this;
      }
    }

    public Criteria andLastChangeCodeLineNotIn(int[] values) {
      if (values.length == 1) {
        return andLastChangeCodeLineNotEqualTo((java.lang.Integer) values[0]);
      } else {
        addCriterion(
            IWorkspaceMemberDAO.LastChangeCodeLine + " not in", values, "lastChangeCodeLine");
        return this;
      }
    }

    public Criteria andLastChangeCodeLineIn(List<java.lang.Integer> values) {

      if (values.size() == 1) {
        return andLastChangeCodeLineEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " in", values, "lastChangeCodeLine");
        return this;
      }
    }

    public Criteria andLastChangeCodeLineNotIn(List<java.lang.Integer> values) {
      if (values.size() == 1) {
        return andLastChangeCodeLineNotEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceMemberDAO.LastChangeCodeLine + " not in", values, "lastChangeCodeLine");
        return this;
      }
    }

    public Criteria andLastChangeCodeLineIn(java.lang.Integer[] values) {

      if (values.length == 1) {
        return andLastChangeCodeLineEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceMemberDAO.LastChangeCodeLine + " in",
            Arrays.asList(values),
            "lastChangeCodeLine");
        return this;
      }
    }

    public Criteria andLastChangeCodeLineNotIn(java.lang.Integer[] values) {
      if (values.length == 1) {
        return andLastChangeCodeLineNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceMemberDAO.LastChangeCodeLine + " not in",
            Arrays.asList(values),
            "lastChangeCodeLine");
        return this;
      }
    }

    public Criteria andLastChangeCodeLineIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastChangeCodeLineNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastChangeCodeLine + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastChangeCodeLineBetween(int value1, int value2) {
      addCriterion(
          IWorkspaceMemberDAO.LastChangeCodeLine + " between",
          value1,
          value2,
          "lastChangeCodeLine");
      return this;
    }

    public Criteria andLastChangeCodeLineBetween(
        java.lang.Integer value1, java.lang.Integer value2) {
      addCriterion(
          IWorkspaceMemberDAO.LastChangeCodeLine + " between",
          value1,
          value2,
          "lastChangeCodeLine");
      return this;
    }

    public Criteria andLastChangeCodeLineNotBetween(int value1, int value2) {
      addCriterion(
          IWorkspaceMemberDAO.LastChangeCodeLine + " not between",
          value1,
          value2,
          "lastChangeCodeLine");
      return this;
    }

    public Criteria andLastChangeCodeLineNotBetween(
        java.lang.Integer value1, java.lang.Integer value2) {
      addCriterion(
          IWorkspaceMemberDAO.LastChangeCodeLine + " not between",
          value1,
          value2,
          "lastChangeCodeLine");
      return this;
    }

    public Criteria andStatusIsNull() {
      addCriterion(IWorkspaceMemberDAO.Status + " is null");
      return this;
    }

    public Criteria andStatusIsNotNull() {
      addCriterion(IWorkspaceMemberDAO.Status + " is not null");
      return this;
    }

    public Criteria andStatusIsNotEmpty() {
      addCriterion(
          IWorkspaceMemberDAO.Status + " is not null AND " + IWorkspaceMemberDAO.Status + " <> ''");
      return this;
    }

    public Criteria andStatusIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceMemberDAO.Status
              + " is null OR "
              + IWorkspaceMemberDAO.Status
              + " = '')");
      return this;
    }

    public Criteria andStatusEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Status + " = ", value, "status");
      return this;
    }

    public Criteria andStatusEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Status);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Status + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceMemberDAO.Status + " is null OR " + IWorkspaceMemberDAO.Status + " <>",
          value,
          "status");
      return this;
    }

    public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Status);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Status + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThan(String value) {

      addCriterion(IWorkspaceMemberDAO.Status + " >", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Status);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Status + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Status + " >=", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Status);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Status + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThan(String value) {

      addCriterion(IWorkspaceMemberDAO.Status + " <", value, "status");
      return this;
    }

    public Criteria andStatusLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Status);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Status + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Status + " <=", value, "status");
      return this;
    }

    public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Status);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Status + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceMemberDAO.Status + " like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceMemberDAO.Status + " not like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusIn(List<String> values) {

      if (values.size() == 1) {
        return andStatusEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.Status + " in", values, "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStatusNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.Status + " not in", values, "status");
        return this;
      }
    }

    public Criteria andStatusIn(String[] values) {

      if (values.length == 1) {
        return andStatusEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.Status + " in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(String[] values) {
      if (values.length == 1) {
        return andStatusNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.Status + " not in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Status + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Status + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusBetween(String value1, String value2) {
      addCriterion(IWorkspaceMemberDAO.Status + " between", value1, value2, "status");
      return this;
    }

    public Criteria andStatusNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceMemberDAO.Status + " not between", value1, value2, "status");
      return this;
    }

    public Criteria andRemarksIsNull() {
      addCriterion(IWorkspaceMemberDAO.Remarks + " is null");
      return this;
    }

    public Criteria andRemarksIsNotNull() {
      addCriterion(IWorkspaceMemberDAO.Remarks + " is not null");
      return this;
    }

    public Criteria andRemarksIsNotEmpty() {
      addCriterion(
          IWorkspaceMemberDAO.Remarks
              + " is not null AND "
              + IWorkspaceMemberDAO.Remarks
              + " <> ''");
      return this;
    }

    public Criteria andRemarksIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceMemberDAO.Remarks
              + " is null OR "
              + IWorkspaceMemberDAO.Remarks
              + " = '')");
      return this;
    }

    public Criteria andRemarksEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Remarks + " = ", value, "remarks");
      return this;
    }

    public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Remarks);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Remarks + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Remarks + " <>", value, "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceMemberDAO.Remarks + " is null OR " + IWorkspaceMemberDAO.Remarks + " <>",
          value,
          "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Remarks);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Remarks + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThan(String value) {

      addCriterion(IWorkspaceMemberDAO.Remarks + " >", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Remarks);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Remarks + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Remarks + " >=", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Remarks);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Remarks + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThan(String value) {

      addCriterion(IWorkspaceMemberDAO.Remarks + " <", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Remarks);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Remarks + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.Remarks + " <=", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.Remarks);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Remarks + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceMemberDAO.Remarks + " like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceMemberDAO.Remarks + " not like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksIn(List<String> values) {

      if (values.size() == 1) {
        return andRemarksEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.Remarks + " in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRemarksNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.Remarks + " not in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(String[] values) {

      if (values.length == 1) {
        return andRemarksEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.Remarks + " in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(String[] values) {
      if (values.length == 1) {
        return andRemarksNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.Remarks + " not in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Remarks + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.Remarks + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksBetween(String value1, String value2) {
      addCriterion(IWorkspaceMemberDAO.Remarks + " between", value1, value2, "remarks");
      return this;
    }

    public Criteria andRemarksNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceMemberDAO.Remarks + " not between", value1, value2, "remarks");
      return this;
    }

    public Criteria andLastActivityTimeIsNull() {
      addCriterion(IWorkspaceMemberDAO.LastActivityTime + " is null");
      return this;
    }

    public Criteria andLastActivityTimeIsNotNull() {
      addCriterion(IWorkspaceMemberDAO.LastActivityTime + " is not null");
      return this;
    }

    public Criteria andLastActivityTimeIsNotEmpty() {
      addCriterion(
          IWorkspaceMemberDAO.LastActivityTime
              + " is not null AND "
              + IWorkspaceMemberDAO.LastActivityTime
              + " <> ''");
      return this;
    }

    public Criteria andLastActivityTimeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceMemberDAO.LastActivityTime
              + " is null OR "
              + IWorkspaceMemberDAO.LastActivityTime
              + " = '')");
      return this;
    }

    public Criteria andLastActivityTimeEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceMemberDAO.LastActivityTime + " = ", value, "lastActivityTime");
      return this;
    }

    public Criteria andLastActivityTimeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastActivityTime);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastActivityTimeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastActivityTime + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastActivityTimeNotEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceMemberDAO.LastActivityTime + " <>", value, "lastActivityTime");
      return this;
    }

    public Criteria andLastActivityTimeNotEqualToOrIsNull(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceMemberDAO.LastActivityTime
              + " is null OR "
              + IWorkspaceMemberDAO.LastActivityTime
              + " <>",
          value,
          "lastActivityTime");
      return this;
    }

    public Criteria andLastActivityTimeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastActivityTime);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastActivityTimeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastActivityTime + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastActivityTimeGreaterThan(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceMemberDAO.LastActivityTime + " >", value, "lastActivityTime");
      return this;
    }

    public Criteria andLastActivityTimeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastActivityTime);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastActivityTimeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastActivityTime + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastActivityTimeGreaterThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceMemberDAO.LastActivityTime + " >=", value, "lastActivityTime");
      return this;
    }

    public Criteria andLastActivityTimeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastActivityTime);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastActivityTimeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastActivityTime + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastActivityTimeLessThan(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceMemberDAO.LastActivityTime + " <", value, "lastActivityTime");
      return this;
    }

    public Criteria andLastActivityTimeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastActivityTime);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastActivityTimeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastActivityTime + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastActivityTimeLessThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceMemberDAO.LastActivityTime + " <=", value, "lastActivityTime");
      return this;
    }

    public Criteria andLastActivityTimeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.LastActivityTime);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastActivityTimeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastActivityTime + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastActivityTimeIn(List<java.util.Date> values) {

      if (values.size() == 1) {
        return andLastActivityTimeEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(
            IWorkspaceMemberDAO.LastActivityTime + " in", values, "lastActivityTime");
        return this;
      }
    }

    public Criteria andLastActivityTimeNotIn(List<java.util.Date> values) {
      if (values.size() == 1) {
        return andLastActivityTimeNotEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(
            IWorkspaceMemberDAO.LastActivityTime + " not in", values, "lastActivityTime");
        return this;
      }
    }

    public Criteria andLastActivityTimeIn(java.util.Date[] values) {

      if (values.length == 1) {
        return andLastActivityTimeEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IWorkspaceMemberDAO.LastActivityTime + " in",
            Arrays.asList(values),
            "lastActivityTime");
        return this;
      }
    }

    public Criteria andLastActivityTimeNotIn(java.util.Date[] values) {
      if (values.length == 1) {
        return andLastActivityTimeNotEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IWorkspaceMemberDAO.LastActivityTime + " not in",
            Arrays.asList(values),
            "lastActivityTime");
        return this;
      }
    }

    public Criteria andLastActivityTimeIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastActivityTime + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastActivityTimeNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.LastActivityTime + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastActivityTimeBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IWorkspaceMemberDAO.LastActivityTime + " between", value1, value2, "lastActivityTime");
      return this;
    }

    public Criteria andLastActivityTimeNotBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IWorkspaceMemberDAO.LastActivityTime + " not between",
          value1,
          value2,
          "lastActivityTime");
      return this;
    }

    public Criteria andWorkspaceIdIsNull() {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " is null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotNull() {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " is not null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotEmpty() {
      addCriterion(
          IWorkspaceMemberDAO.WorkspaceId
              + " is not null AND "
              + IWorkspaceMemberDAO.WorkspaceId
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceMemberDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceMemberDAO.WorkspaceId
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(long value) {
      return andWorkspaceIdEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " = ", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.WorkspaceId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(long value) {
      return andWorkspaceIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " <>", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(long value) {
      return andWorkspaceIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceMemberDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceMemberDAO.WorkspaceId
              + " <>",
          value,
          "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.WorkspaceId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(long value) {
      return andWorkspaceIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " >", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.WorkspaceId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(long value) {
      return andWorkspaceIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " >=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.WorkspaceId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThan(long value) {
      return andWorkspaceIdLessThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " <", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.WorkspaceId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(long value) {
      return andWorkspaceIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " <=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.WorkspaceId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andWorkspaceIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andWorkspaceIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andWorkspaceIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.WorkspaceId + " in", Arrays.asList(values), "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceMemberDAO.WorkspaceId + " not in", Arrays.asList(values), "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " not between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceMemberDAO.WorkspaceId + " not between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andUserNameIsNull() {
      addCriterion(IWorkspaceMemberDAO.UserName + " is null");
      return this;
    }

    public Criteria andUserNameIsNotNull() {
      addCriterion(IWorkspaceMemberDAO.UserName + " is not null");
      return this;
    }

    public Criteria andUserNameIsNotEmpty() {
      addCriterion(
          IWorkspaceMemberDAO.UserName
              + " is not null AND "
              + IWorkspaceMemberDAO.UserName
              + " <> ''");
      return this;
    }

    public Criteria andUserNameIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceMemberDAO.UserName
              + " is null OR "
              + IWorkspaceMemberDAO.UserName
              + " = '')");
      return this;
    }

    public Criteria andUserNameEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.UserName + " = ", value, "userName");
      return this;
    }

    public Criteria andUserNameEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.UserName);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andUserNameEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.UserName + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andUserNameNotEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.UserName + " <>", value, "userName");
      return this;
    }

    public Criteria andUserNameNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceMemberDAO.UserName + " is null OR " + IWorkspaceMemberDAO.UserName + " <>",
          value,
          "userName");
      return this;
    }

    public Criteria andUserNameNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.UserName);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andUserNameNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.UserName + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andUserNameGreaterThan(String value) {

      addCriterion(IWorkspaceMemberDAO.UserName + " >", value, "userName");
      return this;
    }

    public Criteria andUserNameGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.UserName);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andUserNameGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.UserName + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andUserNameGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.UserName + " >=", value, "userName");
      return this;
    }

    public Criteria andUserNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.UserName);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andUserNameGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.UserName + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andUserNameLessThan(String value) {

      addCriterion(IWorkspaceMemberDAO.UserName + " <", value, "userName");
      return this;
    }

    public Criteria andUserNameLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.UserName);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andUserNameLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.UserName + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andUserNameLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceMemberDAO.UserName + " <=", value, "userName");
      return this;
    }

    public Criteria andUserNameLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceMemberDAO.UserName);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andUserNameLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.UserName + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andUserNameLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceMemberDAO.UserName + " like", buffer.toString(), "userName");
      return this;
    }

    public Criteria andUserNameNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceMemberDAO.UserName + " not like", buffer.toString(), "userName");
      return this;
    }

    public Criteria andUserNameIn(List<String> values) {

      if (values.size() == 1) {
        return andUserNameEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.UserName + " in", values, "userName");
        return this;
      }
    }

    public Criteria andUserNameNotIn(List<String> values) {
      if (values.size() == 1) {
        return andUserNameNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceMemberDAO.UserName + " not in", values, "userName");
        return this;
      }
    }

    public Criteria andUserNameIn(String[] values) {

      if (values.length == 1) {
        return andUserNameEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.UserName + " in", Arrays.asList(values), "userName");
        return this;
      }
    }

    public Criteria andUserNameNotIn(String[] values) {
      if (values.length == 1) {
        return andUserNameNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceMemberDAO.UserName + " not in", Arrays.asList(values), "userName");
        return this;
      }
    }

    public Criteria andUserNameIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.UserName + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andUserNameNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceMemberDAO.UserName + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andUserNameBetween(String value1, String value2) {
      addCriterion(IWorkspaceMemberDAO.UserName + " between", value1, value2, "userName");
      return this;
    }

    public Criteria andUserNameNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceMemberDAO.UserName + " not between", value1, value2, "userName");
      return this;
    }
  }
}
